package org.example.rmsmsapi.Utils;
import org.springframework.stereotype.Service;

import javax.crypto.Cipher;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
@Service
    public class RsaMethod {
        // 算法名称
        private static final String ALGORITHM = "RSA";
        // 密钥长度（推荐2048位或以上，安全性更高）
        private static final int KEY_SIZE = 2048;
        // 加密模式
        private static final String TRANSFORMATION = "RSA/ECB/PKCS1Padding";
        /*初始化公钥*/
        public static PublicKey publicKey;
        public static PrivateKey privateKey;
        // 获取加密公钥
        public static PublicKey getpublicKeyValue() {
            return publicKey;
        }
        // 修改加密公钥，这里不需要
        public static void setpublicKeyValue(String value) {
        }
        //获取解密私钥
        public static PrivateKey getPrivateKeyValue() {
            return privateKey;
        }


        /**
         * 生成RSA密钥对（包含公钥和私钥）
         * @return 密钥对
         * @throws NoSuchAlgorithmException 算法不支持异常
         */
        public static KeyPair generateKeyPair() throws NoSuchAlgorithmException {
            // 获取RSA密钥生成器
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
            // 设置密钥长度
            keyPairGenerator.initialize(KEY_SIZE);
            // 生成密钥对
            return keyPairGenerator.generateKeyPair();
        }

        /**
         * 公钥加密
         * @param data 待加密的数据（字符串）
         * @param publicKey 公钥
         * @return 加密后的Base64字符串
         * @throws Exception 加密异常
         */
        public static String encryptByPublicKey(String data, PublicKey publicKey) throws Exception {
            // 创建加密器
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            // 初始化加密模式和公钥
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            // 加密数据（字符串转字节数组，使用UTF-8编码）
            byte[] encryptedData = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
            // 加密后的字节数组转Base64字符串（方便传输和存储）
            return Base64.getEncoder().encodeToString(encryptedData);
        }

        /**
         * 私钥解密
         * @param encryptedData 加密后的Base64字符串
         * @param privateKey 私钥
         * @return 解密后的原始字符串
         * @throws Exception 解密异常
         */
        public static String decryptByPrivateKey(String encryptedData, PrivateKey privateKey) throws Exception {
            // Base64字符串转字节数组
            byte[] data = Base64.getDecoder().decode(encryptedData);
            // 创建解密器
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            // 初始化解密模式和私钥
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            // 解密数据
            byte[] decryptedData = cipher.doFinal(data);
            // 字节数组转字符串（使用UTF-8编码）
            return new String(decryptedData, StandardCharsets.UTF_8);
        }

        /**
         * 公钥字节数组转PublicKey对象
         * @param publicKeyBytes 公钥字节数组
         * @return PublicKey对象
         * @throws Exception 转换异常
         */
        public static PublicKey getPublicKey(byte[] publicKeyBytes) throws Exception {
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
            return keyFactory.generatePublic(keySpec);
        }

        /**
         * 私钥字节数组转PrivateKey对象
         * @param privateKeyBytes 私钥字节数组
         * @return PrivateKey对象
         * @throws Exception 转换异常
         */
        public static PrivateKey getPrivateKey(byte[] privateKeyBytes) throws Exception {
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
            return keyFactory.generatePrivate(keySpec);
        }

        /*公钥加密数据*/
        public static void RsaEncrypt() {

        }
        /*私钥解密数据*/
        public static void RsaDecrypt() {

        }

        public static void InitRsakey() {
            try {
                // 1. 生成密钥对
                KeyPair keyPair = generateKeyPair();
                publicKey = keyPair.getPublic();
                privateKey = keyPair.getPrivate();

                // 打印公钥和私钥（实际应用中需妥善保存，私钥绝对保密）
//                System.out.println("公钥（Base64）：" + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
//                System.out.println("私钥（Base64）：" + Base64.getEncoder().encodeToString(privateKey.getEncoded()));

//                // 2. 原始数据
//                String originalData = "这是一段需要用RSA加密的数据";
//                System.out.println("原始数据：" + originalData);
//
//                // 3. 公钥加密
//                String encryptedData = encryptByPublicKey(originalData, publicKey);
//                System.out.println("加密后的数据：" + encryptedData);
//
//                // 4. 私钥解密
//                String decryptedData = decryptByPrivateKey(encryptedData, privateKey);
//                System.out.println("解密后的数据：" + decryptedData);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


